The type error you are describing is because your signature looks like:

fn run_alice<P: Precision, CB: CircuitBuilder>(b: &mut LocalBuilder<P>, epr_alice: CB::Register, bit_a: bool, bit_b: bool) -> CB::Register {
    match (bit_a, bit_b) {
        (false, false) => epr_alice,
        (false, true) => b.x(epr_alice),
        (true, false) => b.z(epr_alice),
        (true, true) => b.y(epr_alice),
    }
}

So while it's taking a CB::Register for epr_alice, it's taking a LocalBuilder for the builder, it should look like:

fn run_alice<P: Precision, CB: CliffordTBuilder<P>>(b: &mut CB, epr_alice: CB::Register, bit_a: bool, bit_b: bool) -> CB::Register {
    match (bit_a, bit_b) {
        (false, false) => epr_alice,
        (false, true) => b.x(epr_alice),
        (true, false) => b.z(epr_alice),
        (true, true) => b.y(epr_alice),
    }
}

Or of course you could lean into the LocalBuilder and ignore the generics:

fn run_alice<P: Precision>(b: &mut LocalBuilder<P>, epr_alice: Qudit, bit_a: bool, bit_b: bool) -> Qudit {
    match (bit_a, bit_b) {
        (false, false) => epr_alice,
        (false, true) => b.x(epr_alice),
        (true, false) => b.z(epr_alice),
        (true, true) => b.y(epr_alice),
    }
}

Quick question, what would we use instead of the program! macro? It seems like it has been removed in the new version.

program! should work - it lives in qip-macro now since it's a procedural macro rather than a macro_rules! one.

OK, got it. Will take a closer look tonight

Feel free to share any thoughts or feedback you have so far. I wanted to ask how does this program! macro work? Initially, I got my functions undetected, and when I clicked the empty main function to run, they got detected? I generally follow a pattern as the code is a bit difficult and want to get this done quickly, why do we use #[cfg(feature = "macros")] on each import and function?

program! Is a procedural macro, which means it is a bit of code that gets compiled before the rest then included into the compiler itself. Basically it lets the programmer make something like a custom interpreter which translates plain text into rust before everything is fed into the normal compiler.

Documentation here

That cfg thing you pointed out is a conditional compilation - basically it says "only try to compile this if the feature called 'macros' is enabled".

Documentation here

I tried to run these examples and there are a large number of compiler errors:

cargo run --example bell_inequalities --all-features

Also to ensure people know to run with the macro feature, we should probably add a note to the main function for when its disabled: see inline comment

While you are still working on these I'm going to convert them to drafts, let me know once they are ready for review.

Hi, @Renmusxd could you have a look at my circuit3 (latest commit) and confirm if it has the right logic? I am not sure what I should return from those circuits functions.

Also, how can I get rid of this error help: a local variable with a similar name exists: 'r' ?

I believe the circuit3 is doing the correct thing - the reason you're getting that error for circuit1 is because you are passing r to program! but there's no variable called r. There is however one called ra so you may have meant that.

So I think I fixed some stuff, if you want run the example, but now I have a consistent error across all three circuits:
^ cannot use the ? operator in a function that returns &[f64] at the end of program!
and help: a local variable with a similar name exists: r2 again inside program!

If you have any tips I can quickly fix this let me know, otherwise later I will dive deeper in the docs

Pulling your most recent commits I am not seeing the errors you are mentioning, that being said those are certainly rust related and not RustQIP related, so RustQIP docs will not be helpful.

If you're not familiar with the ? operator I'd recommend reading the book:
See the whole page but also specifically this section.

The second error you mentioned is just an undefined variable. I can improve the docs for program! to clarify things but it goes like this:

let res = program!(builder; r1, r2, r3, ...; exprs)

Where builder is an expression that evaluates to a mutable circuit builder (I will be more specific with type requirements in docs.
And r1 through rN are expressions of type Builder::Register, they must pass ownership.

The error you are describing is likely because you wrote r when r was not defined up to that point, so r didn't have the correct type (or any type).